const
  ConverterSecretName = "`converter`"

proc converterKey(c: var SemContext; n: TypeCursor): string =
  var n = n
  while n.kind in {MutT, SinkT, PtrT, RefT, OutT, InvokeT}:
    inc n
  result = ConverterSecretName & toString(n, false)

proc converterMatch(c: var SemContext; m: var Match; f, a: TypeCursor;
                    apos: int; info: PackedLineInfo): bool =
  # we speed this up by checking if type `a` can have any converter attached to it:
  let k = converterKey(c, a)
  var converters: seq[SymId] = @[]

  let localConverters = c.m.iface.getOrDefault(k)
  for defId in items localConverters:
    converters.add defId

  for imported in items c.importedModules:
    let candidates = c.p[imported].iface.getOrDefault(k)
    for defId in candidates:
      converters.add defId

  var orig = NoSymId
  result = false
  for conv in items converters:
    # f(a)
    # --> f(conv(a)) ?
    # conv's return type must match `f`.
    # conv's input type must match `a`.
    let retType = returnType(conv)
    let inputType = firstParam(conv)

    # first match the input argument of `conv` so that the unification algorithm works as expected:
    let res = typeRel(inputType, a)
    var resB = Different
    case res
    of Same, Subtype:
      resB = typeRel(f, retType)
    of Generic:
      let retTypeInst = instReturnType(retType, context.bindings)
      resB = typeRel(f, retTypeInst)
    of Different:
      discard
    if resB != Different:
      if orig == NoSymId:
        orig = conv

        m.hiddenCalls[apos] = r
        inc m.usedConverters

        m.argTypes[apos] = f

        result = true
      else:
        # ambiguous match. For now don't report:
        result = false
        break